import logging
from abc import ABC, abstractmethod
from typing import Dict, List, Any, Optional
from datetime import datetime

class BaseProcessor(ABC):
    """
    数据处理器基类，定义数据处理的基本接口和通用方法
    """
    
    def __init__(self, config: Dict[str, Any] = None):
        """
        初始化处理器
        
        Args:
            config: 处理器配置
        """
        self.config = config or {}
        self.logger = logging.getLogger(f"processor.{self.__class__.__name__}")
    
    @abstractmethod
    def process(self, data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
        """
        处理数据
        
        Args:
            data: 要处理的数据列表
            
        Returns:
            处理后的数据列表
        """
        pass
    
    def clean_text(self, text: str) -> str:
        """
        清理文本，去除多余空格、特殊字符等
        
        Args:
            text: 原始文本
            
        Returns:
            清理后的文本
        """
        if not text:
            return ""
        
        # 替换多个空格为单个空格
        text = ' '.join(text.split())
        
        # 去除特殊字符
        text = text.replace('\u200b', '').replace('\u200c', '')
        
        return text.strip()
    
    def add_metadata(self, item: Dict[str, Any]) -> Dict[str, Any]:
        """
        添加处理元数据
        
        Args:
            item: 数据项
            
        Returns:
            添加元数据后的数据项
        """
        item['processed_at'] = datetime.now().isoformat()
        item['processor'] = self.__class__.__name__
        return item
    
    def filter_invalid(self, data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
        """
        过滤无效数据项
        
        Args:
            data: 数据列表
            
        Returns:
            过滤后的数据列表
        """
        valid_data = []
        for item in data:
            # 检查必要字段
            if not item.get('title'):
                self.logger.warning(f"Skipping item without title: {item.get('id', 'unknown')}")
                continue
                
            valid_data.append(item)
            
        self.logger.info(f"Filtered {len(data) - len(valid_data)} invalid items")
        return valid_data
    
    def deduplicate(self, data: List[Dict[str, Any]], key: str = 'id') -> List[Dict[str, Any]]:
        """
        去除重复数据
        
        Args:
            data: 数据列表
            key: 用于去重的键
            
        Returns:
            去重后的数据列表
        """
        seen = set()
        unique_data = []
        
        for item in data:
            item_key = item.get(key)
            if not item_key:
                # 如果没有指定的key，则保留
                unique_data.append(item)
                continue
                
            if item_key not in seen:
                seen.add(item_key)
                unique_data.append(item)
                
        self.logger.info(f"Deduplicated {len(data) - len(unique_data)} items by {key}")
        return unique_data 